////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  afalgotuningelements.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef AFALGOTUNINGELEMENTS_H
#define AFALGOTUNINGELEMENTS_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "afglobalelements.h"

#define AFALGOTUNINGELEMENTS_NAMESPACE_BEGIN namespace afalgotuningelements {
#define AFALGOTUNINGELEMENTS_NAMESPACE_END }

AFALGOTUNINGELEMENTS_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixSagCompensation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixSagCompensation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enable
    ///
    /// Description:   Enable/Disable lens sag compensation.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32  enable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fDAC - Array
    ///
    /// Description:   fDAC
    /// Range:         [0,unbounded]
    /// Min Length:    1
    /// Max Length:    3
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32  fDACCount;
    UINT32  fDACID;
    UINT32* fDAC;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fDistance
    ///
    /// Description:   fDistance
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT   fDistance;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// triggerThreshold
    ///
    /// Description:   triggerThreshold
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT   triggerThreshold;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixModuleTuningReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixModuleTuningReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lensSagCompensation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixSagCompensation lensSagCompensation;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableHysteresisOffset
    ///
    /// Description:   It enables/disables Hysteresis compensation by provided offset. If Peak is found by only coarse search,
    ///                shift-offset for compensating hysteresis is needed in case of open loop type, especially far area.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type         enableHysteresisOffset;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// chromatixHysteresisOffset
    ///
    /// Description:   Max depending on tuning circumstance. It's the offset value of hysteresis compensation. Please check with
    ///                AFChromatixEnableHysteresisOffset.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                    chromatixHysteresisOffset;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFOutdoorConfigurationReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFOutdoorConfigurationReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// EnableOutdoorROITune
    ///
    /// Description:   It enhances AF performance in bright spot with low contrast of indoor. Finally, it makes outdoor ROI be
    ///                configured or downsized. We can have situation which indoor and outdoor ROI should be compromised
    ///                simultaneously. This is the case: Outdoor ROI should be downsized because we change the ROI for not
    ///                letting bright spot with low contrast in ROI.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type EnableOutdoorROITune;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// OutdoorROIRatioX
    ///
    /// Description:   It provides Outdoor ROI x Ratio from chromatix. Please check with AFChromatix_ENOutdoorROITune.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            OutdoorROIRatioX;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// OutdoorROIRatioY
    ///
    /// Description:   It provides Outdoor ROI y Ratio from chromatix. Please check with AFChromatix_ENOutdoorROITune.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            OutdoorROIRatioY;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFOrientationDetectionReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFOrientationDetectionReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gravityXLandscapeThreshold
    ///
    /// Description:   a gravity x-axis threshold to determine is device orientation in landscape mode.
    /// Range:         [0,9.8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT gravityXLandscapeThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gravityYLandscapeThreshold
    ///
    /// Description:   a gravity y-axis threshold to determine is device orientation in landscape mode.
    /// Range:         [0,9.8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT gravityYLandscapeThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gravityXPortraitThreshold
    ///
    /// Description:   a gravity x-axis threshold to determine is device orientation in portrait mode.
    /// Range:         [0,9.8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT gravityXPortraitThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gravityYPortraitThreshold
    ///
    /// Description:   a gravity y-axis threshold to determine is device orientation in portrait mode.
    /// Range:         [0,9.8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT gravityYPortraitThreshold;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFFaceDetectionReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFFaceDetectionReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// robustFaceDetectEnable
    ///
    /// Description:   1 will enable robust fd af feature and 0 will disable it. This feature is required to make existing FD
    ///                based CAF more robust and reduce hunting in some problematic scene. Below 4 param are related to it.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type robustFaceDetectEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// nofaceCountThreshold
    ///
    /// Description:   number of frame threshold after that we wont delay fd based trigger even if scene is not changed.
    ///                Normally keep it very high value like 30sec-1min, (frames as per 30fps, we internally adjust for fps
    ///                change)
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            nofaceCountThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stableCountThreshold
    ///
    /// Description:   number of frame threshold to wait when fd report face detected but scene is not changed and roi size is
    ///                similar to prev. normally it should be around 3-4sec. (frames as per 30fps, we internally adjust for fps
    ///                change)
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            stableCountThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceDetectionROIPositionChangeThreshold
    ///
    /// Description:   Percentage of coordinate change from previous reported roi, Used to minimize CAF trigger when fd report
    ///                coordinate very similar. Should be around 5-15%
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            faceDetectionROIPositionChangeThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceLostTriggerEnable
    ///
    /// Description:   This is optional feature to enable logic where we trigger caf when face lost reported from fd even if
    ///                scene is not changed, This is useful for corcer-face case but this doesn't go well with robust fd logic,
    ///                so should be enabled with robust only with proper tuning of thresholds.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type faceLostTriggerEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceLostStableThreshold
    ///
    /// Description:   number of frame threshold to wait for no face frame after reporting face lost from fd before we trigger
    ///                caf if faceLostTriggerEnable enabled. Value should be around 1-5sec.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            faceLostStableThreshold;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFFaceDetectionROITuningReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFFaceDetectionROITuningReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FDROITune
    ///
    /// Description:   In some cases, FD ROI includes non-face area, such as it's located backward from the face. This causes AF
    ///                is focusing to the backward high frequency area instead of face area and it causes blurred face shot. It
    ///                makes ROI be downsized. It can be solved with multi grid ROI, but some target doesn't provide it. In such
    ///                case, it's worth.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type FDROITune;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FDROIRatio
    ///
    /// Description:   It provides FD ROI Ratio from chromatix with AFChromatix_EN_FDROITune. Please check with
    ///                AFChromatixFDROITune.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            FDROIRatio;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFFaceROIExtensionReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFFaceROIExtensionReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ROIFaceExtensionEnable
    ///
    /// Description:   a switch to turn on face ROI extension which extend ROI region from face detection region and gravity
    ///                information to include hair region and neck region to avoid flat focus value. Constraints: enable to
    ///                include hair region, but may including some background region.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type ROIFaceExtensionEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ROIFaceScaleX
    ///
    /// Description:   Face ROI width will be (1+scale) times of width of face detection region.Constraints: set too large will
    ///                include background region. Should not set too high due to no face region in extra horizontal region.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            ROIFaceScaleX;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ROIFaceScaleY
    ///
    /// Description:   Face ROI height will be (1+scale) times of height of face detection region. Constraints: this parameter
    ///                enlarge vertical ROI region from face detection region and include hair region and neck region. It will
    ///                avoid flat focus region when face is too smooth.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            ROIFaceScaleY;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ROIFaceSymmetricX
    ///
    /// Description:   decide how face ROI extend to left/right side. Value 0.5 means symmetric extension. 0 means extend to
    ///                left. 1 means extend to right.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            ROIFaceSymmetricX;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ROIFaceSymmetricY
    ///
    /// Description:   decide how face ROI extend to up/down side. Value 0.5 means symmetric extension. 1 means extend to
    ///                upside. 0 means extend to downside.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            ROIFaceSymmetricY;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixFDPriorityCAF
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixFDPriorityCAF
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// positionChangeThreshold
    ///
    /// Description:   Controls when to reconfigure ROI when position has changed with respect to last stable ROI.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT positionChangeThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// positionStableThresholdHigh
    ///
    /// Description:   Percentage difference between last and current position above this value indicates face is moving and not
    ///                stable to trigger new search.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT positionStableThresholdHigh;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// positionStableThresholdLow
    ///
    /// Description:   Position is deemed stable only after face position change is less than this threshold.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT positionStableThresholdLow;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sizeChangeThreshold
    ///
    /// Description:   Threshold to check if size change has decreased enough to be considered stable.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT sizeChangeThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// oldNewSizeDifferenceThreshold
    ///
    /// Description:   Percentage difference between last biggest face and current biggest face to check if we should start
    ///                focusing on new face.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT oldNewSizeDifferenceThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stableCountSize
    ///
    /// Description:   Number of frames face size should remain stable to trigger new search.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 stableCountSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stableCountPosition
    ///
    /// Description:   Number of frames face position should remain stable to trigger new search.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 stableCountPosition;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// noFaceWaitThreshold
    ///
    /// Description:   Number of frames to wait to reset default ROI once face disappears.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 noFaceWaitThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fpsAdjustmentThreshold
    ///
    /// Description:   If current fps falls below this threshold we'll adjust stability counts.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 fpsAdjustmentThreshold;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixFaceDetectionTuningType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixFaceDetectionTuningType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceDetectionPriority
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixFDPriorityCAF                       faceDetectionPriority;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceROIExtension
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFFaceROIExtensionReserveType       faceROIExtension;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceDetectionROITuning
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFFaceDetectionROITuningReserveType faceDetectionROITuning;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceDetection
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFFaceDetectionReserveType          faceDetection;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceHVWeight
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct faceHVWeightStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// enable
        ///
        /// Description:   flag to decide whether we should use difference weight for H and V FV value.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        BOOL  enable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// hWeight
        ///
        /// Description:   Focus value will be hWeight*H+(1-hWeight)*V for face case.
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT hWeight;
    } faceHVWeight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceFarEnd
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct faceFarEndStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// enable
        ///
        /// Description:   when enable , new far end will be used for face fine search.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        afglobalelements::enable_flag_type enable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// farEnd
        ///
        /// Description:   this value will be updated as the new lens far end when fine search happened for face ROI.
        /// Range:         [0,1000]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        INT32            farEnd;
    } faceFarEnd;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixFocusModeSearchLimitType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixFocusModeSearchLimitType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enable
    ///
    /// Description:   Determines whether the stats of the first frame will be skipped or not.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// nearEnd
    ///
    /// Description:   Nearest position lens can move to in this mode
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32           nearEnd;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// farEnd
    ///
    /// Description:   Farest position lens can move to in this mode
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32           farEnd;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// defaultPosition
    ///
    /// Description:   Default lens reset position in current focus mode.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32           defaultPosition;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixFOVCorrection
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixFOVCorrection
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enable
    ///
    /// Description:   Enable/Disable FOV compenstation function in AF side.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 enable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fudgeFactor
    ///
    /// Description:   Compensation factor inorder to get the right crop factor
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT  fudgeFactor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// anchorLensPosition1
    ///
    /// Description:   Lens position corresponding to the anchor_distance_mm_1 Need to specify the lens position, can refer to
    ///                Contrast AF tuning settings from single_index_t
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  anchorLensPosition1;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// anchorLensPosition2
    ///
    /// Description:   Lens position corresponding to the anchor_distance_mm_2 Need to specify the lens position, can refer to
    ///                Contrast AF tuning settings from single_index_t
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  anchorLensPosition2;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// anchorDistanceMM1
    ///
    /// Description:   Physical distance in millimeters at which anchor_lens_pos1 corresponds to.
    /// Range:         [0,3000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  anchorDistanceMM1;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// anchorDistanceMM2
    ///
    /// Description:   Physical distance in millimeters at which anchor_lens_pos2 corresponds to.
    /// Range:         [0,3000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  anchorDistanceMM2;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// focusConvergeStepSizeBrightLight
    ///
    /// Description:   Step size for focus converge in bright light
    /// Range:         [0,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  focusConvergeStepSizeBrightLight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fineSearchStepSizeBrightLight
    ///
    /// Description:   Step size for fine search in bright light
    /// Range:         [0,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  fineSearchStepSizeBrightLight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// focusConvergeStepSizeLowLight
    ///
    /// Description:   Step size for focus converge in low light
    /// Range:         [0,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  focusConvergeStepSizeLowLight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fineSearchStepSizeLowLight
    ///
    /// Description:   Step size for fine search in low light
    /// Range:         [0,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  fineSearchStepSizeLowLight;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFCommonType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFCommonType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// positionNearEnd
    ///
    /// Description:   Nearest position lens can move to.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 positionNearEnd;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// positionDefaultInMacro
    ///
    /// Description:   Default lens rest position when focus mode is Macro.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 positionDefaultInMacro;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// positionBoundary
    ///
    /// Description:   Determines near end of search range for Normal focus mode.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 positionBoundary;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// positionDefaultInNormal
    ///
    /// Description:   Default lens reset position when focus mode is other than macro.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 positionDefaultInNormal;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// positionFarEnd
    ///
    /// Description:   Farthest point of the search range.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 positionFarEnd;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// positionNormalHyperfocal
    ///
    /// Description:   Normal position of the lens when focus fails.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 positionNormalHyperfocal;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// positionMacroRegion
    ///
    /// Description:   Starting lens position of macro region.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 positionMacroRegion;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lowLightGainThreshold
    ///
    /// Description:   When the AEC gain is above this threshold, we assume it's low light condition.
    /// Range:         [0,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 lowLightGainThreshold;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFAlgoTuningType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFAlgoTuningType
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// parameter_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct parameter_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } parameter_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// commonElements
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFCommonType                      commonElements;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FOVCorrection
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixFOVCorrection                     FOVCorrection;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// searchLimit - Array
    /// Min Length:    1
    /// Max Length:    5
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                                     searchLimitCount;
    UINT32                                     searchLimitID;
    chromatixFocusModeSearchLimitType*         searchLimit;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceDetection
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixFaceDetectionTuningType           faceDetection;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// orientationDetection
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFOrientationDetectionReserveType orientationDetection;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// outdoorROIConfiguration
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFOutdoorConfigurationReserveType outdoorROIConfiguration;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// moduleTuning
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixModuleTuningReserveType           moduleTuning;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// setInvalidFrame
    ///
    /// Description:   Determines whether the stats of the first frame will be skipped or not.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type                           setInvalidFrame;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// handJitter
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct handJitterStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// AFSingle
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct AFSingleStruct
        {
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// Binary file symbol table entry ID
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 SymbolTableID;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable
            ///
            /// Description:   Enable/Disable Hand jitter function in single AF algorithm
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            BOOL         enable;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// maxFVInBeginning
            ///
            /// Description:   Check is max fv in first frame
            /// Range:         [0,1]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            FLOAT        maxFVInBeginning;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// coarseSearch
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            struct coarseSearchStruct
            {
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// Binary file symbol table entry ID
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                UINT32 SymbolTableID;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// minSampleSize
                ///
                /// Description:   Minimum stats number for LSP curve fitting calculation during coarse search
                /// Range:         [1,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                UINT32 minSampleSize;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// currentGyroscopeThreshold
                ///
                /// Description:   Minimum HJ threshold of average gyro square value during coarse search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT  currentGyroscopeThreshold;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// currentGyroscopeSTDThreshold
                ///
                /// Description:   Minimum HJ threshold of the STD of gyro square value during coarse search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT  currentGyroscopeSTDThreshold;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// gyroscopeThresholdForDifferenceRatio
                ///
                /// Description:   Minimum HJ threshold of gyro square value need to calculate gyro ratio during coarse search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT  gyroscopeThresholdForDifferenceRatio;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// gyroscodeDifferenceRatioThreshold
                ///
                /// Description:   Minimum HJ threshold of gyro difference ratio during fine search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT  gyroscodeDifferenceRatioThreshold;
            } coarseSearch;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// fineSearch
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            struct fineSearchStruct
            {
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// Binary file symbol table entry ID
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                UINT32 SymbolTableID;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// minSampleSize
                ///
                /// Description:   Minimum stats number for LSP curve fitting calculation during fine search
                /// Range:         [1,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                UINT32       minSampleSize;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// currentGyroscopeThreshold
                ///
                /// Description:   Minimum HJ threshold of average gyro square value during coarse search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT        currentGyroscopeThreshold;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// currentGyroscopeSTDThreshold
                ///
                /// Description:   Minimum HJ threshold of the STD of gyro square value during coarse search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT        currentGyroscopeSTDThreshold;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// gyroscopeThresholdForDifferenceRatio
                ///
                /// Description:   Minimum HJ threshold of gyro square value need to calculate gyro ratio during coarse search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT        gyroscopeThresholdForDifferenceRatio;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// gyroscodeDifferenceRatioThreshold
                ///
                /// Description:   Minimum HJ threshold of gyro difference ratio during fine search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT        gyroscodeDifferenceRatioThreshold;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// FVNormalized
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                struct FVNormalizedStruct
                {
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// Binary file symbol table entry ID
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    UINT32 SymbolTableID;

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// enable
                    ///
                    /// Description:   Turn on HJ filter process during fine search
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    BOOL   enable;

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// highGyroscopeDifferenceThreshold
                    ///
                    /// Description:   Highest threshold of gyro difference of HJ filter process
                    /// Range:         [0,10]
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    FLOAT  highGyroscopeDifferenceThreshold;

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// lowGyroscopeDifferenceThreshold
                    ///
                    /// Description:   Lowest threshold of gyro difference of HJ filter process
                    /// Range:         [0,10]
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    FLOAT  lowGyroscopeDifferenceThreshold;

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// highGryoscopeFVWeight
                    ///
                    /// Description:   Focus value weight when gyro difference is above AF_LSP_HJ_High_Gyro_Diff_Thrs
                    /// Range:         [0,1]
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    FLOAT  highGryoscopeFVWeight;

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// weightType
                    ///
                    /// Description:   choose how to decide FV weight in filter process. 0 use gyro to decide weight. 1 use gyro_diff to decide
                    ///                weight
                    /// Range:         [0,1]
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    UINT32 weightType;
                } FVNormalized;
            } fineSearch;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// redoRateThreshold
            ///
            /// Description:   Percentage ratio to retrigger AF search (HJ stats number/ All stats number)
            /// Range:         [0,1]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            FLOAT        redoRateThreshold;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// handleNeedCount
            ///
            /// Description:   Minimum HJ stats count threshold to trigger HJ algorithm
            /// Range:         [0,10]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32       handleNeedCount;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// resetDataBeforeFineSearch
            ///
            /// Description:   Turn on Stats reset function before enter fine search
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            BOOL         resetDataBeforeFineSearch;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// workingExposureIndex
            ///
            /// Description:   Minimum exposure index requirement to enter HJ algorithm
            /// Range:         [0,1024]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32       workingExposureIndex;
        } AFSingle;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// HAFFineSearch
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct HAFFineSearchStruct
        {
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// Binary file symbol table entry ID
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 SymbolTableID;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable
            ///
            /// Description:   enable/disable Hand Jitter function in HAF fine search
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            BOOL       enable;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// fineSearch
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            struct fineSearchStruct
            {
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// Binary file symbol table entry ID
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                UINT32 SymbolTableID;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// minSampleSize
                ///
                /// Description:   Minimum stats number for LSP curve fitting calculation during HAF fine search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                UINT32       minSampleSize;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// currentGyroscopeThreshold
                ///
                /// Description:   Minimum HJ threshold of average gyro square value during HAF fine search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT        currentGyroscopeThreshold;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// currentGyroscopeSTDThreshold
                ///
                /// Description:   Minimum HJ threshold of the STD of gyro square value during HAF fine search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT        currentGyroscopeSTDThreshold;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// gyroscopeThresholdForDifferenceRatio
                ///
                /// Description:   Minimum HJ threshold of gyro square value need to calculate gyro ratio during HAF search
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT        gyroscopeThresholdForDifferenceRatio;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// gyroscodeDifferenceRatioThreshold
                ///
                /// Description:   Minimum HJ stats count threshold to trigger HJ algorithm
                /// Range:         [0,10]
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                FLOAT        gyroscodeDifferenceRatioThreshold;

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /// FVNormalized
                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                struct FVNormalizedStruct
                {
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// Binary file symbol table entry ID
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    UINT32 SymbolTableID;

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// enable
                    ///
                    /// Description:   Enable/Disable HJ filter process during fine search
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    BOOL   enable;

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// highGyroscopeDifferenceThreshold
                    ///
                    /// Description:   Highest threshold of gyro difference of HJ filter process
                    /// Range:         [0,10]
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    FLOAT  highGyroscopeDifferenceThreshold;

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// lowGyroscopeDifferenceThreshold
                    ///
                    /// Description:   Lowest threshold of gyro difference of HJ filter process
                    /// Range:         [0,10]
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    FLOAT  lowGyroscopeDifferenceThreshold;

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// highGryoscopeFVWeight
                    ///
                    /// Description:   Focus value weight when gyro difference is above HAF_LSP_HJ_High_Gyro_Diff_Thrs
                    /// Range:         [0,1]
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    FLOAT  highGryoscopeFVWeight;

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    /// weightType
                    ///
                    /// Description:   choose how to decide FV weight in filter process. 0 use gyro to decide weight. 1 use gyro_diff to decide
                    ///                weight
                    /// Range:         [0,1]
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    UINT32 weightType;
                } FVNormalized;
            } fineSearch;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// handleNeedCount
            ///
            /// Description:   Minimum HJ threshold of gyro difference ratio during HAF fine search
            /// Range:         [0,10]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32     handleNeedCount;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// workingExposureIndex
            ///
            /// Description:   Minimum exposure index requirement to enter HJ algorithm
            /// Range:         [0,1024]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32     workingExposureIndex;
        } HAFFineSearch;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// samplingRate
        ///
        /// Description:   Hand jitter need higher sample Gryo sample rate. This value specified how much is Gyro sample rate when
        ///                Hand Jitter function enable
        /// Range:         [0,1024]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32        samplingRate;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// reportingRate
        ///
        /// Description:   Hand jitter need higher sample Gryo sample rate. This value specified how much is Gyro report rate when
        ///                Hand Jitter function enable
        /// Range:         [0,1024]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32        reportingRate;
    } handJitter;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// spotlightDetection
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct spotlightDetectionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// enable
        ///
        /// Description:   Enable/Disable spotlight detection in AF function
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        BOOL             enable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// statsType
        ///
        /// Description:   Range: [0 or 1] 0 - 16x16 YSum stats 1 - 64x48 BG stats; Description: This flag determines spotlight
        ///                detection algorithm stats type. When value is 0, it runs with default 16x16 YSum stats. If the value is
        ///                1, then SPD will run with 64x48 BG stats which provides finer granularity. Constraints: None
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        INT32            statsType;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// bgStatsThreshAutoConvertEnable
        ///
        /// Description:   When enable, all the YSum spotlight tuning thresholds will be auto converted to BG stats compatible
        ///                thresholds. For example, if spotlight tuning thresholds are start_h = 4 and end_h = 12, then with BG auto
        ///                convert, it will directly runtime change thresholds to start_h = 16 and en_h = 48(By multiplying the
        ///                BG/YSum grid ratio). If it is disabled, then the grids will be use as it is, and no auto-convert will
        ///                happen.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        afglobalelements::enable_flag_type bgStatsThreshAutoConvertEnable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// bgStatsBrightRegionSatRatioThresh
        ///
        /// Description:   While running BG stats spotlight detection, if any bright region detection zone grid has saturation ratio
        ///                higher than this threshold, then the grid will be count as a bright region.
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            bgStatsBrightRegionSatRatioThresh;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// far_flat_th
        ///
        /// Description:   flat_threshold for far scene when detecting spotlight condition
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            far_flat_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// marco_flat_th
        ///
        /// Description:   flat_threshold for marco scene when detecting spotlight condition
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            marco_flat_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// inc_flat_th
        ///
        /// Description:   inc_flat_threshold to judge current af position is in increase or flat condition
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            inc_flat_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// dec_flat_th
        ///
        /// Description:   dec_flat_threshold to judge current af position is in decrease or flat condition
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            dec_flat_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// spotlight_zone_start_h
        ///
        /// Description:   Defines the horizontal start region of spotlight zone in 16x16 total regions
        /// Range:         [0,15]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           spotlight_zone_start_h;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// spotlight_zone_end_h
        ///
        /// Description:   Defines the horizontal end region of spotlight zone in 16x16 total regions, the spotlight zone horizontal
        ///                end region = spotlight_zone_end_h - 1
        /// Range:         [1,16]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           spotlight_zone_end_h;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// spotlight_zone_start_v
        ///
        /// Description:   Defines the vertical start region of spotlight zone in 16x16 total regions
        /// Range:         [0,15]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           spotlight_zone_start_v;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// spotlight_zone_end_v
        ///
        /// Description:   Defines the vertical end region of spotlight zone in 16x16 total regions, the spotlight zone vertical end
        ///                region = spotlight_zone_end_v - 1
        /// Range:         [1,16]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           spotlight_zone_end_v;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// background_zone_start_h
        ///
        /// Description:   Defines the horizontal start region of background zone in 16x16 total regions
        /// Range:         [0,15]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           background_zone_start_h;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// background_zone_end_h
        ///
        /// Description:   Defines the horizontal end region of background zone in 16x16 total regions, the background zone
        ///                horizontal end region = background_zone_end_h - 1
        /// Range:         [1,16]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           background_zone_end_h;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// background_zone_start_v
        ///
        /// Description:   Defines the vertical start region of background zone in 16x16 total regions
        /// Range:         [0,15]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           background_zone_start_v;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// background_zone_end_v
        ///
        /// Description:   Defines the vertical end region of background zone in 16x16 total regions, the background zone vertical
        ///                end region = background_zone_end_v - 1
        /// Range:         [1,16]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           background_zone_end_v;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// exposure_index_trigger_th
        ///
        /// Description:   if exposure index is smaller than this threshold, the spotlight will not be detected
        /// Range:         [200,400]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        INT32            exposure_index_trigger_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// background_luma_avg_th
        ///
        /// Description:   If the average luma of background zone is higher than this threshold, the spotlight will not be detected
        /// Range:         [1,255]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           background_luma_avg_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// region_low_grey_th
        ///
        /// Description:   Defines the low grey luma threshold. If luma is smaller than this threshold, it will be recognized as a
        ///                low grey region, suggest to disable it by default value 255
        /// Range:         [1,255]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           region_low_grey_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// region_low_dark_th
        ///
        /// Description:   Defines the dark grey luma threshold. If luma is smaller than this threshold, it will be recognized as a
        ///                dark grey region, good to keep default value
        /// Range:         [1,255]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           region_low_dark_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// background_low_grey_pct_th
        ///
        /// Description:   if the low grey percentage is higher than this threshold, the low grey flag will be raised. Suggest to
        ///                disable it by default
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            background_low_grey_pct_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// background_dark_grey_pct_th
        ///
        /// Description:   if the dark grey percentage is higher than this threshold, the dark grey flag will be raised
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            background_dark_grey_pct_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// bright_region_luma_delta_background_zone
        ///
        /// Description:   if regions luma is higher than average luma of background zone multiply this parameter, this region will
        ///                be recognize as a bright region
        /// Range:         [0,8]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            bright_region_luma_delta_background_zone;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// bright_region_luma_delta_spotlight_zone_low_grey
        ///
        /// Description:   In low grey condition and cluster is enabled,if regions luma is higher than average luma of background
        ///                zone multiply. This parameter, this region will be recognize as a bright region
        /// Range:         [0,8]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            bright_region_luma_delta_spotlight_zone_low_grey;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// bright_region_luma_delta_spotlight_zone_dark_grey
        ///
        /// Description:   In dark grey condition and cluster is enabled,if regions luma is higher than average luma of background
        ///                zone multiply. This parameter, this region will be recognize as a bright region
        /// Range:         [0,8]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            bright_region_luma_delta_spotlight_zone_dark_grey;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// square_cluster_inc_size
        ///
        /// Description:   The maximum bright region will be the center region and the square cluster size will depends on the
        ///                parameter, set to 0 will disable this cluster effect
        /// Range:         [0,2]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           square_cluster_inc_size;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// vertical_cluster_inc_size
        ///
        /// Description:   The maximum bright region will be the center region and the vertical cluster size will depends on the
        ///                parameter, set to 0 will disable this cluster effect
        /// Range:         [0,2]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           vertical_cluster_inc_size;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// horizontal_cluster_inc_size
        ///
        /// Description:   The maximum bright region will be the center region and the vertical cluster size will depends on the
        ///                parameter, set to 0 will disable this cluster effect
        /// Range:         [0,2]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           horizontal_cluster_inc_size;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// square_cluster_pct_th
        ///
        /// Description:   If the bright region percentage of square cluster zones is higher this threshold, the flag of
        ///                square_bright_region_cluster will be raised
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            square_cluster_pct_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// vertical_cluster_pct_th
        ///
        /// Description:   If the bright region percentage of vertical cluster zones is higher this threshold, the flag of
        ///                vertical_bright_region_cluster will be raised
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            vertical_cluster_pct_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// horizontal_cluster_pct_th
        ///
        /// Description:   If the bright region percentage of horizontal cluster zones is higher this threshold, the flag of
        ///                horizontal_bright_region_cluster will be raised
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            horizontal_cluster_pct_th;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// spotlight_detect_cnt_th
        ///
        /// Description:   Spotlight detect flag threshold. Only if consecutive success spotlight detect over the threshold count
        ///                will result in the final spotlight detected flag be updated.
        /// Range:         [1,unbounded]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           spotlight_detect_cnt_th;
    } spotlightDetection;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFFocusModeType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class chromatixAFFocusModeType
{
    AFFocusModeAuto       = 0,
    AFFocusModeContinuous = 1,
    AFFocusModeInfinity   = 2,
    AFFocusModeMacro      = 3,
    AFFocusModeManual     = 4
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFAlgoTuningTypeClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class chromatixAFAlgoTuningTypeClass : public ParameterModule, public chromatixAFAlgoTuningType
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const UINT16 MAJOR = 3;
    static const UINT16 MINOR = 4;
    static const UINT32 PATCH = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFAlgoTuningTypeClass(
        const CHAR* name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFAlgoTuningTypeClass(
        const CHAR* name,
        UINT32 modeId,
        UINT16 mode,
        UINT16 subMode,
        UINT32 group);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~chromatixAFAlgoTuningTypeClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixSagCompensation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixSagCompensation(
        ParameterFileSymbolTableEntry* entry,
        chromatixSagCompensation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixModuleTuningReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixModuleTuningReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixModuleTuningReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFOutdoorConfigurationReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFOutdoorConfigurationReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFOutdoorConfigurationReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFOrientationDetectionReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFOrientationDetectionReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFOrientationDetectionReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFFaceDetectionReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFFaceDetectionReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFFaceDetectionReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFFaceDetectionROITuningReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFFaceDetectionROITuningReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFFaceDetectionROITuningReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFFaceROIExtensionReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFFaceROIExtensionReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFFaceROIExtensionReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixFDPriorityCAF
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixFDPriorityCAF(
        ParameterFileSymbolTableEntry* entry,
        chromatixFDPriorityCAF* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixFaceDetectionTuningType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixFaceDetectionTuningType(
        ParameterFileSymbolTableEntry* entry,
        chromatixFaceDetectionTuningType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixFaceDetectionTuningType_faceHVWeightStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixFaceDetectionTuningType_faceHVWeightStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixFaceDetectionTuningType::faceHVWeightStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixFaceDetectionTuningType_faceFarEndStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixFaceDetectionTuningType_faceFarEndStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixFaceDetectionTuningType::faceFarEndStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixFocusModeSearchLimitType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixFocusModeSearchLimitType(
        ParameterFileSymbolTableEntry* entry,
        chromatixFocusModeSearchLimitType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixFOVCorrection
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixFOVCorrection(
        ParameterFileSymbolTableEntry* entry,
        chromatixFOVCorrection* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFCommonType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFCommonType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFCommonType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFAlgoTuningType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFAlgoTuningType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadmodule_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType::module_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load parameter_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadparameter_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType::parameter_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load handJitterStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadhandJitterStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType::handJitterStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load handJitterStruct_AFSingleStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadhandJitterStruct_AFSingleStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType::handJitterStruct::AFSingleStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load handJitterStruct_handJitterStruct_AFSingleStruct_coarseSearchStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadhandJitterStruct_handJitterStruct_AFSingleStruct_coarseSearchStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType::handJitterStruct::AFSingleStruct::coarseSearchStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load handJitterStruct_handJitterStruct_AFSingleStruct_fineSearchStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadhandJitterStruct_handJitterStruct_AFSingleStruct_fineSearchStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType::handJitterStruct::AFSingleStruct::fineSearchStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load handJitterStruct_handJitterStruct_AFSingleStruct_handJitterStruct_handJitterStruct_AFSingleStruct_fineSearchStruct_FVNormalizedStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadhandJitterStruct_handJitterStruct_AFSingleStruct_handJitterStruct_handJitterStruct_AFSingleStruct_fineSearchStruct_FVNormalizedStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType::handJitterStruct::AFSingleStruct::fineSearchStruct::FVNormalizedStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load handJitterStruct_HAFFineSearchStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadhandJitterStruct_HAFFineSearchStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType::handJitterStruct::HAFFineSearchStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load handJitterStruct_handJitterStruct_HAFFineSearchStruct_fineSearchStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadhandJitterStruct_handJitterStruct_HAFFineSearchStruct_fineSearchStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType::handJitterStruct::HAFFineSearchStruct::fineSearchStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load handJitterStruct_handJitterStruct_HAFFineSearchStruct_handJitterStruct_handJitterStruct_HAFFineSearchStruct_fineSearchStruct_FVNormalizedStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadhandJitterStruct_handJitterStruct_HAFFineSearchStruct_handJitterStruct_handJitterStruct_HAFFineSearchStruct_fineSearchStruct_FVNormalizedStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType::handJitterStruct::HAFFineSearchStruct::fineSearchStruct::FVNormalizedStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load spotlightDetectionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadspotlightDetectionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFAlgoTuningType::spotlightDetectionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixSagCompensation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixSagCompensation(
        chromatixSagCompensation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixModuleTuningReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixModuleTuningReserveType(
        chromatixModuleTuningReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixAFAlgoTuningType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixAFAlgoTuningType(
        chromatixAFAlgoTuningType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Parse symbol table entry, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Parse(
        ParameterSetManager* manager,
        ParameterFileSymbolTableEntry* entry) const;

}; // End class chromatixAFAlgoTuningTypeClass

AFALGOTUNINGELEMENTS_NAMESPACE_END
#endif // AFALGOTUNINGELEMENTS_H

